home *** CD-ROM | disk | FTP | other *** search
/ Aminet 37 / Aminet 37 (2000)(Schatztruhe)[!][Jun 2000].iso / Aminet / biz / dopus / DOpus414JRsrc.lha / DirectoryOpus4 / DOpus_Print / printdir.c < prev    next >
C/C++ Source or Header  |  2000-01-29  |  17KB  |  533 lines
  1. /*
  2.  
  3. Directory Opus 4
  4. Original GPL release version 4.12
  5. Copyright 1993-2000 Jonathan Potter
  6.  
  7. This program is free software; you can redistribute it and/or
  8. modify it under the terms of the GNU General Public License
  9. as published by the Free Software Foundation; either version 2
  10. of the License, or (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20.  
  21. All users of Directory Opus 4 (including versions distributed
  22. under the GPL) are entitled to upgrade to the latest version of
  23. Directory Opus version 5 at a reduced price. Please see
  24. http://www.gpsoft.com.au for more information.
  25.  
  26. The release of Directory Opus 4 under the GPL in NO WAY affects
  27. the existing commercial status of Directory Opus 5.
  28.  
  29. */
  30.  
  31. #include "print.h"
  32.  
  33. #define PD_SIZE 1
  34. #define PD_DATE 2
  35. #define PD_PROT 4
  36. #define PD_COMM 8
  37. #define PD_TYPE 16
  38.  
  39. #define ENTRY_FILE              -1
  40. #define ENTRY_DEVICE             0
  41. #define ENTRY_DIRECTORY          1
  42. #define ENTRY_CUSTOM           999
  43. #define CUSTOMENTRY_DIRTREE      1
  44. #define CUSTOMENTRY_BUFFERLIST   2
  45. #define CUSTOMENTRY_USER         3
  46.  
  47. enum {
  48.     PRINTDIR_SIZE,
  49.     PRINTDIR_DATE,
  50.     PRINTDIR_PROTECTION,
  51.     PRINTDIR_COMMENT,
  52.     PRINTDIR_FILETYPE,
  53.     PRINTDIR_PRINTER,
  54.     PRINTDIR_FILE,
  55.     PRINTDIR_FILEREQUESTER,
  56.     PRINTDIR_FILESTRING,
  57.     PRINTDIR_PRINT,
  58.     PRINTDIR_EXIT,
  59.  
  60.     PRINTDIR_NUM_GADGETS};
  61.  
  62. struct TagItem
  63.     printdir_size_gadget[]={
  64.         {RO_Type,OBJECT_GADGET},
  65.         {RO_GadgetType,GADGET_CHECK},
  66.         {RO_GadgetID,PRINTDIR_SIZE},
  67.         {RO_Top,1},
  68.         {RO_TopFine,4},
  69.         {RO_LeftFine,20},
  70.         {RO_TextNum,STR_SIZE},
  71.         {RO_TextPos,TEXTPOS_RIGHT},
  72.         {RO_BoolOn,TRUE},
  73.         {RO_ChkCenter,TRUE},
  74.         {TAG_END,0}},
  75.     printdir_date_gadget[]={
  76.         {RO_Type,OBJECT_GADGET},
  77.         {RO_GadgetType,GADGET_CHECK},
  78.         {RO_GadgetID,PRINTDIR_DATE},
  79.         {RO_Top,2},
  80.         {RO_TopFine,9},
  81.         {RO_LeftFine,20},
  82.         {RO_TextNum,STR_DATE},
  83.         {RO_TextPos,TEXTPOS_RIGHT},
  84.         {RO_BoolOn,TRUE},
  85.         {RO_ChkCenter,TRUE},
  86.         {TAG_END,0}},
  87.     printdir_protection_gadget[]={
  88.         {RO_Type,OBJECT_GADGET},
  89.         {RO_GadgetType,GADGET_CHECK},
  90.         {RO_GadgetID,PRINTDIR_PROTECTION},
  91.         {RO_Top,1},
  92.         {RO_TopFine,4},
  93.         {RO_Left,10},
  94.         {RO_LeftFine,71},
  95.         {RO_TextNum,STR_PROTECTION},
  96.         {RO_TextPos,TEXTPOS_RIGHT},
  97.         {RO_BoolOn,TRUE},
  98.         {RO_ChkCenter,TRUE},
  99.         {TAG_END,0}},
  100.     printdir_comment_gadget[]={
  101.         {RO_Type,OBJECT_GADGET},
  102.         {RO_GadgetType,GADGET_CHECK},
  103.         {RO_GadgetID,PRINTDIR_COMMENT},
  104.         {RO_Top,2},
  105.         {RO_TopFine,9},
  106.         {RO_Left,10},
  107.         {RO_LeftFine,71},
  108.         {RO_TextNum,STR_COMMENT},
  109.         {RO_TextPos,TEXTPOS_RIGHT},
  110.         {RO_ChkCenter,TRUE},
  111.         {TAG_END,0}},
  112.     printdir_filetype_gadget[]={
  113.         {RO_Type,OBJECT_GADGET},
  114.         {RO_GadgetType,GADGET_CHECK},
  115.         {RO_GadgetID,PRINTDIR_FILETYPE},
  116.         {RO_Top,3},
  117.         {RO_TopFine,14},
  118.         {RO_LeftFine,20},
  119.         {RO_TextNum,STR_FILETYPE},
  120.         {RO_TextPos,TEXTPOS_RIGHT},
  121.         {RO_ChkCenter,TRUE},
  122.         {TAG_END,0}},
  123.  
  124.     printdir_printer_gadget[]={
  125.         {RO_Type,OBJECT_GADGET},
  126.         {RO_GadgetType,GADGET_RADIO},
  127.         {RO_GadgetID,PRINTDIR_PRINTER},
  128.         {RO_Top,5},
  129.         {RO_TopFine,24},
  130.         {RO_LeftFine,22},
  131.         {RO_TextNum,STR_PRINTER},
  132.         {RO_TextPos,TEXTPOS_RIGHT},
  133.         {RO_BoolOn,TRUE},
  134.         {RO_ChkCenter,TRUE},
  135.         {TAG_END,0}},
  136.     printdir_file_gadget[]={
  137.         {RO_Type,OBJECT_GADGET},
  138.         {RO_GadgetType,GADGET_RADIO},
  139.         {RO_GadgetID,PRINTDIR_FILE},
  140.         {RO_Top,6},
  141.         {RO_TopFine,28},
  142.         {RO_LeftFine,22},
  143.         {RO_TextNum,STR_FILE},
  144.         {RO_TextPos,TEXTPOS_RIGHT},
  145.         {RO_ChkCenter,TRUE},
  146.         {TAG_END,0}},
  147.     printdir_filerequester_gadget[]={
  148.         {RO_Type,OBJECT_GADGET},
  149.         {RO_GadgetType,GADGET_TINYGLASS},
  150.         {RO_GadgetID,PRINTDIR_FILEREQUESTER},
  151.         {RO_Left,8},
  152.         {RO_LeftFine,45},
  153.         {RO_Top,6},
  154.         {RO_TopFine,26},
  155.         {RO_Height,1},
  156.         {RO_HeightFine,4},
  157.         {RO_WidthFine,24},
  158.         {RO_HighRecess,TRUE},
  159.         {TAG_END,0}},
  160.     printdir_filestring_gadget[]={
  161.         {RO_Type,OBJECT_GADGET},
  162.         {RO_GadgetType,GADGET_STRING},
  163.         {RO_GadgetID,PRINTDIR_FILESTRING},
  164.         {RO_Left,8},
  165.         {RO_LeftFine,75},
  166.         {RO_Top,6},
  167.         {RO_TopFine,28},
  168.         {RO_Width,32},
  169.         {RO_WidthFine,-59},
  170.         {RO_Height,1},
  171.         {RO_StringLen,256},
  172.         {TAG_END,0}},
  173.  
  174.     printdir_print_gadget[]={
  175.         {RO_Type,OBJECT_GADGET},
  176.         {RO_GadgetType,GADGET_BOOLEAN},
  177.         {RO_GadgetID,PRINTDIR_PRINT},
  178.         {RO_Top,7},
  179.         {RO_TopFine,34},
  180.         {RO_Width,12},
  181.         {RO_Height,1},
  182.         {RO_HeightFine,4},
  183.         {RO_TextNum,STR_PRINT},
  184.         {RO_TextPos,TEXTPOS_CENTER},
  185.         {RO_HighRecess,TRUE},
  186.         {TAG_END,0}},
  187.     printdir_exit_gadget[]={
  188.         {RO_Type,OBJECT_GADGET},
  189.         {RO_GadgetType,GADGET_BOOLEAN},
  190.         {RO_GadgetID,PRINTDIR_EXIT},
  191.         {RO_Left,28},
  192.         {RO_LeftFine,20},
  193.         {RO_Top,7},
  194.         {RO_TopFine,34},
  195.         {RO_Width,12},
  196.         {RO_Height,1},
  197.         {RO_HeightFine,4},
  198.         {RO_TextNum,STR_EXIT},
  199.         {RO_TextPos,TEXTPOS_CENTER},
  200.         {RO_HighRecess,TRUE},
  201.         {TAG_END,0}},
  202.  
  203.     printdir_print_text[]={
  204.         {RO_Type,OBJECT_TEXT},
  205.         {RO_TopFine,2},
  206.         {RO_TextNum,STR_PRINT_DOT},
  207.         {TAG_END,0}},
  208.  
  209.     printdir_output_text[]={
  210.         {RO_Type,OBJECT_TEXT},
  211.         {RO_Top,4},
  212.         {RO_TopFine,21},
  213.         {RO_TextNum,STR_OUTPUT_TO},
  214.         {TAG_END,0}},
  215.  
  216.     *printdir_gadgets[]={
  217.         printdir_size_gadget,
  218.         printdir_date_gadget,
  219.         printdir_protection_gadget,
  220.         printdir_comment_gadget,
  221.         printdir_filetype_gadget,
  222.         printdir_printer_gadget,
  223.         printdir_file_gadget,
  224.         printdir_filerequester_gadget,
  225.         printdir_filestring_gadget,
  226.         printdir_print_gadget,
  227.         printdir_exit_gadget,
  228.         NULL};
  229.  
  230. int printdir_string(struct RequesterBase *,int,char *);
  231. void printdirectory(struct RequesterBase *reqbase,char *portname,int flags,char *output,int wind);
  232. void save_printdir_env(int flags,int printer,char *filename);
  233. void read_printdir_env(int *flags,int *printer,char *filename);
  234.  
  235. void do_printdir(vis,portname,wind)
  236. struct VisInfo *vis;
  237. char *portname;
  238. int wind;
  239. {
  240.     struct RequesterBase printdirreq;
  241.     struct IntuiMessage *msg;
  242.     struct Window *window;
  243.     struct Gadget *gadgets[PRINTDIR_NUM_GADGETS];
  244.     ULONG class;
  245.     USHORT code,gadgetid;
  246.     APTR iaddress;
  247.     struct StringExtend stringex;
  248.     struct Requester busyreq;
  249.     char *printdir_filestring_buffer;
  250.     int a,printflags;
  251.  
  252.     printdirreq.rb_width=40;
  253.     printdirreq.rb_height=8;
  254.     printdirreq.rb_flags=0;
  255.  
  256.     fill_out_req(&printdirreq,vis);
  257.  
  258.     printdirreq.rb_privateflags=0;
  259.     printdirreq.rb_screenname=NULL;
  260.  
  261.     if (printdirreq.rb_screen && !(vis->vi_flags&VISF_BORDERS)) {
  262.         printdirreq.rb_flags|=RBF_STRINGS;
  263.         printdirreq.rb_title=NULL;
  264.     }
  265.     else {
  266.         printdirreq.rb_flags|=RBF_BORDERS|RBF_CLOSEGAD|RBF_STRINGS;
  267.         printdirreq.rb_title=string_table[STR_PRINTDIR];
  268.     }
  269.  
  270.     printdirreq.rb_widthfine=45;
  271.     printdirreq.rb_heightfine=45;
  272.     printdirreq.rb_leftoffset=13;
  273.     printdirreq.rb_topoffset=3;
  274.  
  275.     printdirreq.rb_extend=&stringex;
  276.     printdirreq.rb_idcmpflags=0;
  277.     printdirreq.rb_string_table=string_table;
  278.  
  279.     for (a=0;a<2;a++) {
  280.         stringex.Pens[a]=vis->vi_stringcol[a];
  281.         stringex.ActivePens[a]=vis->vi_activestringcol[a];
  282.     }
  283.     stringex.InitialModes=0;
  284.     stringex.EditHook=NULL;
  285.     stringex.WorkBuffer=NULL;
  286.     for (a=0;a<4;a++) stringex.Reserved[a]=0;
  287.  
  288.     if (!(window=OpenRequester(&printdirreq)) ||
  289.         !(addreqgadgets(&printdirreq,printdir_gadgets,gadgets)) ||
  290.         !(AddRequesterObject(&printdirreq,printdir_print_text)) ||
  291.         !(AddRequesterObject(&printdirreq,printdir_output_text))) {
  292.         CloseRequester(&printdirreq);
  293.         return;
  294.     }
  295.  
  296.     RefreshRequesterObject(&printdirreq,NULL);
  297.  
  298.     printdir_filestring_buffer=
  299.         ((struct StringInfo *)gadgets[PRINTDIR_FILESTRING]->SpecialInfo)->Buffer;
  300.  
  301.     read_printdir_env(&printflags,&a,printdir_filestring_buffer);
  302.     if (!a) {
  303.         gadgets[PRINTDIR_PRINTER]->Flags&=~GFLG_SELECTED;
  304.         gadgets[PRINTDIR_FILE]->Flags|=GFLG_SELECTED;
  305.     }
  306.     for (a=0;a<5;a++) {
  307.         if (printflags&(1<<a)) gadgets[a]->Flags|=GFLG_SELECTED;
  308.         else gadgets[a]->Flags&=~GFLG_SELECTED;
  309.     }
  310.     
  311.     RefreshGList(gadgets[0],window,NULL,-1);
  312.  
  313.     FOREVER {
  314.         while (msg=(struct IntuiMessage *)GetMsg(window->UserPort)) {
  315.             class=msg->Class; code=msg->Code;
  316.             iaddress=msg->IAddress;
  317.             ReplyMsg((struct Message *)msg);
  318.  
  319.             switch (class) {
  320.                 case IDCMP_GADGETDOWN:
  321.                     gadgetid=((struct Gadget *)iaddress)->GadgetID;
  322.  
  323.                     switch (gadgetid) {
  324.  
  325.                         case PRINTDIR_PRINTER:
  326.                             gadgets[PRINTDIR_PRINTER]->Flags|=GFLG_SELECTED;
  327.                             gadgets[PRINTDIR_FILE]->Flags&=~GFLG_SELECTED;
  328.                             RefreshGList(gadgets[PRINTDIR_PRINTER],window,NULL,2);
  329.                             break;
  330.  
  331.                         case PRINTDIR_FILE:
  332.                             gadgets[PRINTDIR_PRINTER]->Flags&=~GFLG_SELECTED;
  333.                             gadgets[PRINTDIR_FILE]->Flags|=GFLG_SELECTED;
  334.                             RefreshGList(gadgets[PRINTDIR_PRINTER],window,NULL,2);
  335.                             break;
  336.                     }
  337.                     break;
  338.  
  339.                 case IDCMP_GADGETUP:
  340.                     gadgetid=((struct Gadget *)iaddress)->GadgetID;
  341.  
  342.                     switch (gadgetid) {
  343.  
  344.                         case PRINTDIR_FILEREQUESTER:
  345.                             if (!(get_file_byrequest(gadgets[PRINTDIR_FILESTRING],window,1)))
  346.                                 break;
  347.                         case PRINTDIR_FILESTRING:
  348.                             RefreshStrGad(gadgets[PRINTDIR_FILESTRING],window);
  349.                             if (gadgets[PRINTDIR_PRINTER]->Flags&GFLG_SELECTED) {
  350.                                 gadgets[PRINTDIR_PRINTER]->Flags&=~GFLG_SELECTED;
  351.                                 gadgets[PRINTDIR_FILE]->Flags|=GFLG_SELECTED;
  352.                                 RefreshGList(gadgets[PRINTDIR_PRINTER],window,NULL,2);
  353.                             }
  354.                             break;
  355.  
  356.                         case PRINTDIR_PRINT:
  357.                             printflags=0;
  358.  
  359.                             for (a=0;a<5;a++) {
  360.                                 if (gadgets[a]->Flags&GFLG_SELECTED) printflags|=1<<a;
  361.                             }
  362.  
  363.                             InitRequester(&busyreq);
  364.                             busyreq.Flags=NOISYREQ;
  365.                             Request(&busyreq,window);
  366.                             SetBusyPointer(window);
  367.  
  368.                             printdirectory(&printdirreq,
  369.                                 portname,printflags,
  370.                                 (gadgets[PRINTDIR_PRINTER]->Flags&GFLG_SELECTED)?"PRT:":
  371.                                     printdir_filestring_buffer,wind);
  372.                             gadgetid=PRINTDIR_EXIT;
  373.  
  374.                             EndRequest(&busyreq,window);
  375.  
  376.                         case PRINTDIR_EXIT:
  377.  
  378.                             code=0x1b;
  379.                             break;
  380.                     }
  381.                     if (gadgetid!=PRINTDIR_EXIT) break;
  382.  
  383.                 case IDCMP_VANILLAKEY:
  384.                     if (code!=0x1b) break;
  385.  
  386.                 case IDCMP_CLOSEWINDOW:
  387.  
  388.                     SetBusyPointer(window);
  389.                     printflags=0;
  390.                     for (a=0;a<5;a++) {
  391.                         if (gadgets[a]->Flags&GFLG_SELECTED) printflags|=1<<a;
  392.                     }
  393.                     save_printdir_env(printflags,
  394.                         (gadgets[PRINTDIR_PRINTER]->Flags&GFLG_SELECTED)?1:0,
  395.                         printdir_filestring_buffer);
  396.  
  397.                     CloseRequester(&printdirreq);
  398.                     return;
  399.             }
  400.         }
  401.         Wait(1<<window->UserPort->mp_SigBit);
  402.     }
  403. }
  404.  
  405. void printdirectory(reqbase,portname,flags,output,wind)
  406. struct RequesterBase *reqbase;
  407. char *portname;
  408. int flags;
  409. char *output;
  410. int wind;
  411. {
  412.     struct PrintDirData pddata;
  413.     char buf[256],pbuf[128];
  414.     int out=0,abort=0;
  415.  
  416.     pddata.win=wind;
  417.     if (!(dopus_message(DOPUSMSG_GETPRINTDIR,(APTR)&pddata,portname)))
  418.         return;
  419.  
  420.     while (!out) {
  421.         if (out=Open(output,MODE_NEWFILE)) break;
  422.         if (!(check_error(reqbase,string_table[STR_UNABLE_TO_OPEN_OUTPUT],0)))
  423.             return;
  424.     }
  425.  
  426.     if (pddata.entry) {
  427.         if (!(printdir_string(reqbase,out,pddata.titlebuf))) {
  428.             Close(out);
  429.             return;
  430.         }
  431.         
  432.         while (pddata.entry) {
  433.             if (check_print_abort(reqbase)) {
  434.                 abort=1;
  435.                 break;
  436.             }
  437.             if (!pddata.onlysel || pddata.entry->selected) {
  438.                 switch (pddata.entry->type) {
  439.                     case ENTRY_CUSTOM:
  440.                         if (pddata.entry->comment &&
  441.                             !(printdir_string(reqbase,out,pddata.entry->comment))) abort=1;
  442.                         break;
  443.                     case ENTRY_DEVICE:
  444.                         lsprintf(buf,"%-32s",pddata.entry->name);
  445.                         if (pddata.entry->comment) strcat(buf,pddata.entry->comment);
  446.                         if (!(printdir_string(reqbase,out,buf))) abort=1;
  447.                         break;
  448.                     default:
  449.                         lsprintf(buf,"%-30s",pddata.entry->name);
  450.                         if (flags&PD_SIZE) {
  451.                             if (pddata.entry->type<=ENTRY_FILE) {
  452.                                 lsprintf(pbuf,"%7ld",pddata.entry->size);
  453.                                 strcat(buf,pbuf);
  454.                             }
  455.                             else strcat(buf,"    Dir");
  456.                         }
  457.                         if (flags&PD_PROT) {
  458.                             strcat(buf," ");
  459.                             strcat(buf,pddata.entry->protbuf);
  460.                         }
  461.                         if (flags&PD_DATE) {
  462.                             strcat(buf," ");
  463.                             strcat(buf,pddata.entry->datebuf);
  464.                         }
  465.                         if (flags&PD_TYPE && pddata.entry->description) {
  466.                             strcat(buf,"(");
  467.                             strcat(buf,pddata.entry->description);
  468.                             strcat(buf,")");
  469.                         }
  470.                         if (!(printdir_string(reqbase,out,buf))) {
  471.                             abort=1;
  472.                             break;
  473.                         }
  474.                         if (flags&PD_COMM && pddata.entry->comment) {
  475.                             StrCombine(buf,": ",pddata.entry->comment,256);
  476.                             if (!(printdir_string(reqbase,out,buf))) abort=1;
  477.                         }
  478.                         break;
  479.                 }
  480.             }
  481.             if (abort) break;
  482.             pddata.entry=pddata.entry->next;
  483.         }
  484.         if (!abort) Write(out,"\n",1);
  485.     }
  486.     Close(out);
  487. }
  488.  
  489. printdir_string(reqbase,file,string)
  490. struct RequesterBase *reqbase;
  491. int file;
  492. char *string;
  493. {
  494.     int len;
  495.  
  496.     FOREVER {
  497.         if ((Write(file,string,(len=strlen(string))))==len) {
  498.             Write(file,"\n",1);
  499.             return(1);
  500.         }
  501.         if (!(check_error(reqbase,string_table[STR_ERROR_PRINTING_DIR],0)))
  502.             return(0);
  503.     }
  504. }
  505.  
  506. void save_printdir_env(flags,printer,filename)
  507. int flags,printer;
  508. char *filename;
  509. {
  510.     int file;
  511.  
  512.     if (file=Open("env:DOpus_printdir.prefs",MODE_NEWFILE)) {
  513.         Write(file,(char *)&flags,sizeof(int));
  514.         Write(file,(char *)&printer,sizeof(int));
  515.         Write(file,filename,strlen(filename)+1);
  516.         Close(file);
  517.     }
  518. }
  519.  
  520. void read_printdir_env(flags,printer,filename)
  521. int *flags,*printer;
  522. char *filename;
  523. {
  524.     int file;
  525.  
  526.     if (file=Open("env:DOpus_printdir.prefs",MODE_OLDFILE)) {
  527.         Read(file,(char *)flags,sizeof(int));
  528.         Read(file,(char *)printer,sizeof(int));
  529.         Read(file,filename,256);
  530.         Close(file);
  531.     }
  532. }
  533.